![[Swift] BrightFuturesで非同期処理をflatMapでつなげる方法](https://devio2023-media.developers.io/wp-content/uploads/2014/11/logo_swift_400x400.png){kind=logo}
[Swift] BrightFuturesで非同期処理をflatMapでつなげる方法
はじめに
こんにちは！
モバイルアプリサービス部の田中孝明です。
こちらのブログの続きのエントリーになります。
Swift 3.0に移行する上で、従来の機能をおさらいしておこうという内容のブログになります。
Future と Promise
Java、Scala、JavaScriptを実装されて事ある方には馴染み深い非同期処理の機構です。
Futureは未来の結果を表し、Promiseは成功と失敗を表す処理や値をFutureに変換する事ができます。
詳しくはFuture と Promiseを参照していただければ幸いです。
SwiftとFuture/Promise
Swiftには残念ながらFuture/Promiseの機構は備わっていません。
しかし、BrightFuturesというライブラリを組み込むことで、Future/Promiseを利用する事ができます。
導入方法に関しては弊社のブログ、[Swift] 非同期処理フレームワークBrightFutures ~導入編~が参考になると思います。
内容がswift3.0以前のものなので、復習も兼ねて書き記していきます。
導入
API通信をFutureで非同期処理するサンプルを作りたいと思います。
今回もCocoaPodsで導入します。
pod 'Alamofire', '~> 4.0.1'
pod 'SwiftyJSON'
pod 'BrightFutures'
post_install do |installer|
installer.pods_project.targets.each do |target|
target.build_configurations.each do |config|
config.build_settings['SWIFT_VERSION'] = '3.0'
end
end
end
AlamofireとSwiftyJSONに関してはAPI通信の際に利用するために導入しています。
FutureとPromiseを利用する場合はBrightFuturesのみで十分です。
モックの作成
ローカルの環境で動作テストするだけですのでjson-serverを利用してJSONを返すだけのモックを用意します。
モック用のjsonファイルは以下のようなものを用意しました。
{
"users": {
"id": 1,
"name": "test-1",
"token": "XXXXXXXXXXXXX"
},
"profile": {
"firstname": "TAKAAKI",
"lastname": "TANAKA"
},
"messages": [
{
"id": 1,
"text": "hello"
},
{
"id": 2,
"text": "nice"
}
]
}
それぞれusers、profile、messagesでアクセスした際に定義された以下のJSONを返却する動作になります。
json-serverはPOSTも対応していますが、今回はGETのみで利用します。
iOSアプリ側でJSONの結果を受け取ってパースした結果を保持するstructを定義しておきます。
struct User {
let id: Int?
let name: String?
let token: String?
init(json: JSON) {
id = json["id"].int
name = json["name"].string
token = json["token"].string
}
}
struct Profile {
let firstname: String?
let lastname: String?
init(json: JSON) {
firstname = json["firstname"].string
lastname = json["lastname"].string
}
}
struct Message {
let id: Int?
let text: String?
init(json: JSON) {
id = json["id"].int
text = json["text"].string
}
}
Future/Promiseを適用しない場合
クロージャを利用して結果を受け取るようにすることが多いのでは無いでしょうか。
var usersComplitionHandler: ((User) -> Void)? var profileComplitionHandler: ((Profile) -> Void)? var messagesComplitionHandler: (([Message]) -> Void)?
// すごく雑な作り方
usersComplitionHandler = { user in
print(user)
}
Alamofire.request("http://localhost:3000/users").responseJSON { [weak self] response in
switch response.result {
case .success(let value):
let json = JSON(value)
let user = User(json: json)
self?.usersComplitionHandler?(user)
case .failure(let error):
print(error)
}
}
Future/Promiseを適用した場合
usersの処理を置き換えてみます。
リクエストの成功をpromise.successに、失敗をpromise.failureに定義します。
promise.futureでFutuerに変換したものを返却します。
private func getUser() -> Future<User, NSError> {
let promise = Promise<User, NSError>()
let queue = DispatchQueue(label: "getUser", attributes: .concurrent)
Alamofire.request("http://localhost:3000/users").responseJSON(queue: queue, completionHandler: { response in
switch response.result {
case .success(let value):
let json = JSON(value)
let user = User(json: json)
promise.success(user)
case .failure(let error):
print(error)
promise.failure(error as NSError)
}
})
return promise.future
}
あとは呼び出し元で成功時の処理をonSuccessと失敗時の処理をonFailureに定義します。
Futureの名前が示す通り、受け取り側は「いずれ結果が返ってくるもの」に対して成功と失敗の処理を書きます。
let userFuture = getUser()
userFuture.onSuccess { user in
print(user)
}.onFailure { error in
print(error)
}
どちらの処理が書きやすいかは主観の域を出ないので、ここでは言及しません。
複数の非同期処理を直列に行う
Future/Promiseを適用しない
Future/Promiseを適用しないで、2つ以上の非同期処理を直列で呼びたい時は、クロージャ内でクロージャを呼ぶなど、多少煩雑になったりします。
試しにusers→profile→messagesを順番に呼び出す処理を記します。
// 絶対真似してはダメ
usersComplitionHandler = { [weak self] user in
Alamofire.request("http://localhost:3000/profile").responseJSON { [weak self] response in
switch response.result {
case .success(let value):
let json = JSON(value)
let profile = Profile(json: json)
self?.profileComplitionHandler?(profile)
case .failure(let error):
print(error)
}
}
}
profileComplitionHandler = { [weak self] profile in
Alamofire.request("http://localhost:3000/messages").responseJSON { [weak self] response in
switch response.result {
case .success(let value):
let json = JSON(value)
let messages = json.arrayValue.map { Message(json: $0) }
self?.messagesComplitionHandler?(messages)
case .failure(let error):
print(error)
}
}
}
messagesComplitionHandler = { [weak self] messages in
print(messages)
}
Alamofire.request("http://localhost:3000/users").responseJSON { [weak self] response in
switch response.result {
case .success(let value):
let json = JSON(value)
let user = User(json: json)
self?.usersComplitionHandler?(user)
case .failure(let error):
print(error)
}
}
クロージャの処理が絡むため、処理の順番が追いにくくなってしまいます。
Future/Promiseを適用
ではFuture/Promiseを適用した場合はどうでしょうか。
まずはusersと同様にprofileとmessagesもFutureで返すように定義します。
private func getProfile(id: Int?) -> Future<Profile, NSError> {
let promise = Promise<Profile, NSError>()
let queue = DispatchQueue(label: "getProfile", attributes: .concurrent)
Alamofire.request("http://localhost:3000/profile").responseJSON(queue: queue, completionHandler: { response in
switch response.result {
case .success(let value):
let json = JSON(value)
let profile = Profile(json: json)
promise.success(profile)
case .failure(let error):
print(error)
promise.failure(error as NSError)
}
})
return promise.future
}
private func getMessages(name: String?) -> Future<[Message], NSError> {
let promise = Promise<[Message], NSError>()
let queue = DispatchQueue(label: "getProfile", attributes: .concurrent)
Alamofire.request("http://localhost:3000/messages").responseJSON(queue: queue, completionHandler: { response in
switch response.result {
case .success(let value):
let json = JSON(value)
let messages = json.arrayValue.map { Message(json: $0) }
promise.success(messages)
case .failure(let error):
print(error)
promise.failure(error as NSError)
}
})
return promise.future
}
FutureにはflatMapが定義されているため、結果をflatMapで繋げて直列に処理する事ができます。
getUser().flatMap { user -> Future<Profile, NSError> in
self.getProfile(id: user.id)
}.flatMap { profile -> Future<[Message], NSError> in
self.getMessages(name: profile.name)
}.onSuccess { messages in
print(messages)
}.onFailure { error in
// 全てのAPIの失敗はこちらに集約される
print(error)
}
それぞれのFutureに対してflatMapで繋げることで、非同期処理を順番に行なう事ができます。
onSuccessには最終的な非同期処理の成功の結果を、onFailureでは全ての非同期処理の失敗が処理されるようになります。
Future/Promiseを利用した事ある方には馴染みのある記法になったのではないでしょうか。
ただし、こちらのブログでも記載した通り、Swiftにはfor（yield）のようなシンタックスシュガーが提供されていないので、多少煩雑に感じるでしょう。
まとめ
Future/Promiseパターンを導入したからといって劇的に非同期処理が楽に書けるようになるとは限らないですが、Java、Scala、JavaScriptで実装した事のある人に馴染みのある記法を使う事で可読性を上げる事ができるのではないでしょうか。
ぜひ標準でサポートしていただきたい機構ではあります。
参考文献
Future と Promise
[Swift] 非同期処理フレームワークBrightFutures ~導入編~
【Scala】flatMap は怖くない！
【Scala】Future と未来のセカイ
![[小ネタ] ラスベガスに到着してからiPhoneのカメラのシャッター音が消えた件 #AWSreInvent](https://devio2023-media.developers.io/wp-content/uploads/2023/11/eyecatch_reinvent-2023-from-lasvegas-dayori.png)
